-- Lua Battle System - 物品管理

local Logger = require("utils.logger")
local ConfigLoader = require("utils.config_loader")
local Item = require("items.item")
local Consumable = require("items.consumable")
local Equipment = require("items.equipment")

local ItemManager = {
    items = {}, -- 已注册的物品列表
    item_configs = {}, -- 物品配置缓存
    drop_tables = {}, -- 掉落表配置
    drop_rates = {} -- 物品掉落率配置
}

-- 初始化物品管理器
function ItemManager:init()
    Logger.info("物品管理器初始化完成")
end

-- 注册物品
function ItemManager:register_item(item)
    if not item.id then
        Logger.error("物品ID不能为空")
        return false
    end
    
    self.items[item.id] = item
    Logger.debug("物品注册成功: " .. item.name .. " (" .. item.id .. ")")
    return true
end

-- 从配置文件加载物品
function ItemManager:load_item_from_config(item_id)
    if self.item_configs[item_id] then
        return self.item_configs[item_id]
    end
    
    -- 从配置文件加载物品配置
    local item_config = ConfigLoader:load_item_config(item_id)
    if not item_config then
        Logger.error("无法加载物品配置: " .. item_id)
        return nil
    end
    
    -- 根据物品类型创建物品实例
    local item
    if item_config.type == "consumable" then
        item = Consumable:new(item_config)
    elseif item_config.type == "equipment" then
        item = Equipment:new(item_config)
    else
        item = Item:new(item_config)
    end
    
    item:init()
    
    -- 注册物品
    self:register_item(item)
    
    -- 缓存物品配置
    self.item_configs[item_id] = item
    
    return item
end

-- 获取物品
function ItemManager:get_item(item_id)
    -- 先从已注册的物品中查找
    local item = self.items[item_id]
    if item then
        return item
    end
    
    -- 如果找不到，尝试从配置文件加载
    return self:load_item_from_config(item_id)
end

-- 获取所有物品
function ItemManager:get_all_items()
    return self.items
end

-- 使用物品
function ItemManager:use_item(user, item_id, target)
    -- 获取物品
    local item = self:get_item(item_id)
    if not item then
        Logger.error("物品不存在: " .. item_id)
        return nil
    end
    
    -- 检查物品是否可用
    if not item:is_usable("battle") then
        Logger.error(user.name .. " 无法使用物品: " .. item.name)
        return nil
    end
    
    -- 执行物品使用
    local result = item:use(user, target)
    if not result then
        Logger.error("物品使用失败: " .. item.name)
        return nil
    end
    
    return result
end

-- 装备物品
function ItemManager:equip_item(user, item_id)
    -- 获取物品
    local item = self:get_item(item_id)
    if not item then
        Logger.error("物品不存在: " .. item_id)
        return false
    end
    
    -- 检查物品类型
    if item.type ~= "equipment" then
        Logger.error(item.name .. " 不是装备物品")
        return false
    end
    
    -- 检查物品是否可以装备
    if not item:can_equip(user) then
        return false
    end
    
    -- 执行装备
    return item:equip(user)
end

-- 卸下装备
function ItemManager:unequip_item(user, slot)
    -- 获取当前装备
    local equipment = user.equipment[slot]
    if not equipment then
        Logger.error(user.name .. " 没有装备 " .. slot .. " 槽位的物品")
        return false
    end
    
    -- 执行卸下
    return equipment:unequip(user)
end

-- 添加物品到角色背包
function ItemManager:add_item_to_inventory(user, item_id, quantity)
    quantity = quantity or 1
    
    -- 获取物品
    local item = self:get_item(item_id)
    if not item then
        Logger.error("物品不存在: " .. item_id)
        return false
    end
    
    -- 检查物品是否可堆叠
    if item.stackable then
        -- 检查背包中是否已有该物品
        if user.items[item_id] then
            user.items[item_id] = user.items[item_id] + quantity
            -- 检查是否超过最大堆叠数量
            if user.items[item_id] > item.max_stack then
                local overflow = user.items[item_id] - item.max_stack
                user.items[item_id] = item.max_stack
                Logger.warn("背包已满，无法完全添加 " .. item.name .. "，剩余 " .. overflow .. " 个无法添加")
            end
        else
            user.items[item_id] = quantity
        end
    else
        -- 非堆叠物品，每个物品占一个槽位
        for i = 1, quantity do
            -- 这里简化处理，实际应该检查背包空间
            user.items[item_id .. "_" .. i] = 1
        end
    end
    
    Logger.info(user.name .. " 获得了 " .. quantity .. " 个 " .. item.name)
    return true
end

-- 从角色背包移除物品
function ItemManager:remove_item_from_inventory(user, item_id, quantity)
    quantity = quantity or 1
    
    -- 检查背包中是否有该物品
    if not user.items[item_id] or user.items[item_id] < quantity then
        Logger.error(user.name .. " 背包中没有足够的 " .. item_id .. "，当前数量: " .. (user.items[item_id] or 0) .. "，需要: " .. quantity)
        return false
    end
    
    -- 移除物品
    user.items[item_id] = user.items[item_id] - quantity
    if user.items[item_id] <= 0 then
        user.items[item_id] = nil
    end
    
    Logger.info(user.name .. " 移除了 " .. quantity .. " 个 " .. item_id)
    return true
end

-- 获取角色背包中的物品列表
function ItemManager:get_inventory_items(user)
    local items = {}
    
    for item_id, quantity in pairs(user.items) do
        -- 对于非堆叠物品，简化处理
        local base_item_id = item_id:match("^([^_]+)")
        local item = self:get_item(base_item_id)
        if item then
            items[item_id] = {
                item = item,
                quantity = quantity
            }
        end
    end
    
    return items
end

-- 预加载所有物品
function ItemManager:preload_all_items()
    Logger.info("开始预加载所有物品...")
    
    -- TODO: 实现从配置目录加载所有物品的逻辑
    -- 这里需要获取配置目录中的所有物品文件，暂时简化处理
    
    Logger.info("物品预加载完成")
end

-- 注册掉落表
function ItemManager:register_drop_table(table_id, drop_table)
    self.drop_tables[table_id] = drop_table
    Logger.info("掉落表注册成功: " .. table_id)
end

-- 生成随机掉落
function ItemManager:generate_drop(drop_table_id, luck_factor)
    luck_factor = luck_factor or 1.0
    
    local drop_table = self.drop_tables[drop_table_id]
    if not drop_table then
        Logger.error("掉落表不存在: " .. drop_table_id)
        return nil
    end
    
    local drops = {}
    
    -- 遍历掉落表中的物品
    for _, drop_entry in ipairs(drop_table.items) do
        -- 计算实际掉落率（考虑幸运值影响）
        local actual_drop_rate = drop_entry.drop_rate * luck_factor
        
        -- 随机决定是否掉落
        if math.random() < actual_drop_rate then
            -- 生成掉落数量
            local quantity = math.random(drop_entry.min_quantity, drop_entry.max_quantity)
            
            -- 添加到掉落列表
            table.insert(drops, {
                item_id = drop_entry.item_id,
                quantity = quantity,
                drop_rate = actual_drop_rate
            })
        end
    end
    
    return drops
end

-- 从掉落表获取物品
function ItemManager:get_items_from_drop(drop_table_id, luck_factor)
    local drops = self:generate_drop(drop_table_id, luck_factor)
    if not drops or #drops == 0 then
        return nil
    end
    
    local items = {}
    
    -- 将掉落转换为实际物品
    for _, drop in ipairs(drops) do
        local item = self:get_item(drop.item_id)
        if item then
            table.insert(items, {
                item = item,
                quantity = drop.quantity
            })
        end
    end
    
    return items
end

-- 应用掉落规则
function ItemManager:apply_drop_rules(drops, context)
    context = context or {}
    
    local filtered_drops = {}
    
    -- 应用掉落规则
    for _, drop in ipairs(drops) do
        local item = self:get_item(drop.item_id)
        if item then
            -- 检查掉落规则
            local can_drop = true
            
            -- 示例规则：根据物品稀有度调整掉落率
            if context.enemy_level then
                local rarity_levels = {
                    common = 1,
                    uncommon = 5,
                    rare = 10,
                    epic = 15,
                    legendary = 20
                }
                
                local required_level = rarity_levels[item.rarity] or 1
                if context.enemy_level < required_level then
                    can_drop = false
                end
            end
            
            if can_drop then
                table.insert(filtered_drops, drop)
            end
        end
    end
    
    return filtered_drops
end

-- 处理物品获取
function ItemManager:handle_item_acquisition(user, drops)
    local acquired_items = {}
    
    for _, drop in ipairs(drops) do
        local success = self:add_item_to_inventory(user, drop.item_id, drop.quantity)
        if success then
            table.insert(acquired_items, drop)
        end
    end
    
    return acquired_items
end

-- 掉落物品给角色
function ItemManager:drop_items_to_character(character, drop_table_id, context)
    context = context or {}
    
    -- 计算幸运因子
    local luck_factor = 1.0 + (character.luck or 0) / 100
    
    -- 生成掉落
    local drops = self:generate_drop(drop_table_id, luck_factor)
    if not drops or #drops == 0 then
        return nil
    end
    
    -- 应用掉落规则
    local filtered_drops = self:apply_drop_rules(drops, context)
    if not filtered_drops or #filtered_drops == 0 then
        return nil
    end
    
    -- 处理物品获取
    return self:handle_item_acquisition(character, filtered_drops)
end

-- 导出模块
return ItemManager